package com.sino.dao.hibernate;

import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.sino.bean.Basicinfo;
import com.sino.bean.Jjxyinfo;
import com.sino.bean.Qtzk;
import com.sino.bean.Sharepeople;
import com.sino.bean.Zjclinfo;
import com.sino.bean.Zlbhzk;
import com.sino.bean.Zlintro;
import com.sino.bean.Zljszk;
import com.sino.dao.IBasicInfoDAO;
import com.sino.second.bean.TblSystemparam;
import com.sino.util.SysParameter;

/**
 * Copyright (C) : Sinodigital Tech. Co., Ltd. Project : 专利项目申请 JDK version used :
 * jdk1.5.0_08 Description : 提供DAO实现类 Version : 1.0 Date : 2008.2.20
 * Modification history : 新建
 */
public class BasicInfoDAO extends HibernateDaoSupport implements IBasicInfoDAO {
	/**
	 * Description ：保存基本信息到数据库中
	 * 
	 * @param basicinfo
	 *            ：基本信息持久化對象
	 */
	public void saveBasicInfo(Basicinfo basicinfo) {
		this.getSession().save(basicinfo);
		this.getSession().flush();
	}

	// 删除基本信息
	public void delBasicInfo(String zlid) {
		Basicinfo basicinfo = (Basicinfo) this.getHibernateTemplate().get(
				Basicinfo.class, zlid);

		/*
		 * if (basicinfo != null) { Set jjxySet = basicinfo.getJjxyinfos();
		 * Iterator it = jjxySet.iterator();
		 * 
		 * //删除年度经济效益 while(it.hasNext()){ Set ndJjxySet =
		 * ((Jjxyinfo)it.next()).getNdjjxies();
		 * this.getHibernateTemplate().deleteAll(ndJjxySet); }
		 * this.getHibernateTemplate().deleteAll(basicinfo.getJjxyinfos());//删除经济效益
		 * 
		 * Zljszk zljszk = basicinfo.getZljszks();
		 * this.getHibernateTemplate().deleteAll(zljszk.getHjqks());//删除获奖情况
		 * this.getHibernateTemplate().delete(zljszk);//专利技术状况
		 * 
		 * this.getHibernateTemplate().deleteAll(basicinfo.getSharepeoples());//删除共有专利权人
		 * this.getHibernateTemplate().deleteAll(basicinfo.getSqqks());//删除申请情况
		 * this.getHibernateTemplate().deleteAll(basicinfo.getXkqks());//删除许可状况
		 * this.getHibernateTemplate().deleteAll(basicinfo.getZjclinfos());//删除证件材料
		 * 
		 * this.getHibernateTemplate().delete(basicinfo.getQtzks());//删除其他状况
		 * this.getHibernateTemplate().delete(basicinfo.getZlintro());//删除项目简介
		 * this.getHibernateTemplate().delete(basicinfo.getZlbhzks());//专利保护状况 }
		 */
		if (basicinfo != null) {
			this.getHibernateTemplate().bulkUpdate(
					"delete from Qtzk qtzk where qtzk.basicinfo.zlid=?", zlid);// 删除其他状况
			this
					.getHibernateTemplate()
					.bulkUpdate(
							"delete from Zlintro zlintro where zlintro.basicinfo.zlid=?",
							zlid);// 删除项目简介
			this.getHibernateTemplate().bulkUpdate(
					"delete from Zlbhzk zlbhzk where zlbhzk.basicinfo.zlid=?",
					zlid);// 专利保护状况
			this.getHibernateTemplate().bulkUpdate(
					"delete from Zlbhzk zlbhzk where zlbhzk.basicinfo.zlid=?",
					zlid);// 专利保护状况

			Set jjxySet = basicinfo.getJjxyinfos();
			Iterator it = jjxySet.iterator();

			// 删除年度经济效益
			while (it.hasNext()) {
				Jjxyinfo jjxyinfo = (Jjxyinfo) it.next();
				this.getHibernateTemplate().bulkUpdate(
						"delete from Ndjjxy ndjjxy where ndjjxy.jjxyinfo.id=?",
						jjxyinfo.getId());
			}
			this
					.getHibernateTemplate()
					.bulkUpdate(
							"delete from Jjxyinfo jjxyinfo where jjxyinfo.basicinfo.zlid=?",
							zlid);// 删除经济效益

			// Zljszk zljszk = basicinfo.getZljszks();
			this.getHibernateTemplate().bulkUpdate(
					"delete from Hjqk hjqk where hjqk.zljszk.zlid=?", zlid);// 删除获奖情况
			this.getHibernateTemplate().bulkUpdate(
					"delete from Zljszk zljszk where zljszk.basicinfo.zlid=?",
					zlid);// 专利技术状况

			this
					.getHibernateTemplate()
					.bulkUpdate(
							"delete from Sharepeople sharepeople where sharepeople.basicinfo.zlid=?",
							zlid);// 删除共有专利权人
			this.getHibernateTemplate().bulkUpdate(
					"delete from Sqqk sqqk where sqqk.basicinfo.zlid=?", zlid);// 删除申请情况
			this.getHibernateTemplate().bulkUpdate(
					"delete from Xkqk xkqk where xkqk.basicinfo.zlid=?", zlid);// 删除许可状况
			this
					.getHibernateTemplate()
					.bulkUpdate(
							"delete from Zjclinfo zjclinfo where zjclinfo.basicinfo.zlid=?",
							zlid);// 删除证件材料
			this.getHibernateTemplate().bulkUpdate(
					"delete from Tjyj tjyj where tjyj.zlid =?", zlid);
			this.getHibernateTemplate().bulkUpdate(
					"delete from Basicinfo basicinfo where basicinfo.zlid =?",
					zlid);
		}
	}

	/**
	 * Description ：更新基本信息到数据库中
	 * 
	 * @param basicinfo
	 *            ：基本信息持久化對象
	 */
	public void updateBasicInfo(Basicinfo basicinfo) {
		this.getHibernateTemplate().update(basicinfo);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：根据时间的专利号码修改密码
	 * 
	 * @param zlid
	 *            ：实际专利编号，
	 * @param passw
	 *            ：密码
	 */
	public void updatePassw(String zlid, String passw) {
		this
				.getHibernateTemplate()
				.bulkUpdate(
						"update Basicinfo basicinfo set basicinfo.passw=? where basicinfo.zlid2=?",
						new String[] { passw, zlid });
	}

	/**
	 * Description ：根据专利编号查找基本信息
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public Basicinfo findBasicinfoById(String zlId) {

		return (Basicinfo) this.getHibernateTemplate().get(Basicinfo.class,
				zlId);
	}

	/**
	 * Description ：根据专利编号查找基本信息
	 * 
	 * @param zlId
	 *            ：专利编号==实际专利号码
	 */
	public List findBasicinfoByZlId(String zlId) {
		return this.getHibernateTemplate().find(
				"from Basicinfo basicinfo where basicinfo.zlid2 = ?", zlId);

	}

	/**
	 * Description ：根据专利编号查找基本信息,查找完毕后存在返回true，不存在返回false，然后请看缓存
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public boolean validateExist(String zlId) {
		boolean retn = false;
		if (this.getHibernateTemplate().get(Basicinfo.class, zlId) != null) {
			retn = true;
			this.getHibernateTemplate().clear();
		}
		return retn;
	}

	/**
	 * Description ：根据专利编号查找基本信息,查找完毕后存在返回true，不存在返回false，然后请看缓存
	 * 
	 * @param zlId
	 *            ：专利编号==实际专利号码
	 */
	public boolean validateExistZlId(String zlId) {
		boolean retn = false;
		List temp = this.getHibernateTemplate().find(
				"from Basicinfo basicinfo where basicinfo.zlid2 = ?", zlId);
		if (temp.size() > 0) {
			retn = true;
			this.getHibernateTemplate().clear();
		}
		return retn;
	}

	// ---------------------------------------------------------------
	/**
	 * Description ：保存专利技术状况信息到数据库中
	 * 
	 * @param zljjzk
	 *            ：专利技术状况信息持久化對象
	 */
	public void saveZljszk(Zljszk zljszk) {
		this.getHibernateTemplate().save(zljszk);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新专利技术状况信息到数据库中
	 * 
	 * @param zljjzk
	 *            ：专利技术状况信息持久化對象
	 */
	public void updateZljszk(Zljszk zljszk) {
		this.getHibernateTemplate().update(zljszk);
	}

	/**
	 * Description ：根据专利编号查找专利技术状况信息
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public Zljszk findZljszkByZlId(String zlId) {
		return (Zljszk) this.getHibernateTemplate().get(Zljszk.class, zlId);
	}

	/**
	 * Description ：根据专利编号查找专利技术状况信息=清除缓存
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public Zljszk findZljszkByZlIdClear(String zlId) {
		Zljszk zljszk = (Zljszk) this.getHibernateTemplate().get(Zljszk.class,
				zlId);
		this.getHibernateTemplate().clear();
		return zljszk;
	}

	// ---------------------------------------------------------------
	/**
	 * Description ：保存经济效益信息到数据库中
	 * 
	 * @param jjxyInfo
	 *            ：经济效益信息持久化對象
	 */
	public void saveJjxyInfo(Jjxyinfo jjxyInfo) {
		this.getHibernateTemplate().save(jjxyInfo);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新经济效益信息到数据库中
	 * 
	 * @param jjxyInfo
	 *            ：经济效益信息持久化對象
	 */
	public void updateJjxyInfo(Jjxyinfo jjxyInfo) {
		this.getHibernateTemplate().update(jjxyInfo);
	}

	/**
	 * Description ：根据专利编号查找经济效益信息
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public List findJjxyByZlId(String zlId) {
		List jjxyList = this.getHibernateTemplate().find(
				"from Jjxyinfo jjxyinfo where jjxyinfo.basicinfo.zlid = ?",
				zlId);
		return jjxyList;
	}

	/**
	 * Description ：根据专利编号查找经济效益信息，同时清除缓存
	 * 
	 * @param zlId
	 *            ：专利编号
	 */
	public List findJjxyByZlIdClear(String zlId) {
		List jjxyList = this.getHibernateTemplate().find(
				"from Jjxyinfo jjxyinfo where jjxyinfo.basicinfo.zlid = ?",
				zlId);
		this.getHibernateTemplate().clear();
		return jjxyList;
	}

	// --------------------------------------------------------------
	/**
	 * Description ：保存专利保护状况信息到数据库中
	 * 
	 * @param zlbhzk
	 *            ：专利保护状况持久化對象
	 */
	public void saveZlbhzk(Zlbhzk zlbhzk) {
		this.getHibernateTemplate().saveOrUpdate(zlbhzk);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新专利保护状况信息到数据库中
	 * 
	 * @param zlbhzk
	 *            ：专利保护状况持久化對象
	 */
	public void updateZlbhzk(Zlbhzk zlbhzk) {
		this.getHibernateTemplate().update(zlbhzk);
	}

	/**
	 * Description ：根据专利id查找专利保护状况
	 * 
	 * @param zlId
	 *            ：专利id
	 */
	public Zlbhzk findZlbhzkById(String zlId) {
		return (Zlbhzk) this.getHibernateTemplate().get(Zlbhzk.class, zlId);
	}

	/**
	 * Description ：根据专利id查找专利保护状况，然后清除缓存
	 * 
	 * @param zlId
	 *            ：专利id
	 */
	public Zlbhzk findZlbhzkByIdClear(String zlId) {
		Zlbhzk zlbhzk;
		zlbhzk = (Zlbhzk) this.getHibernateTemplate().get(Zlbhzk.class, zlId);
		this.getHibernateTemplate().clear();
		return zlbhzk;

	}

	// ----------------------------------------------------------------
	/**
	 * Description ：保存专利保护状况信息到数据库中
	 * 
	 * @param qtzk
	 *            ：其他状况持久化對象
	 */
	public void saveQtzk(Qtzk qtzk) {
		this.getHibernateTemplate().save(qtzk);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新专利保护状况信息到数据库中
	 * 
	 * @param qtzk
	 *            ：其他状况持久化對象
	 */
	public void updateQtzk(Qtzk qtzk) {
		this.getHibernateTemplate().update(qtzk);
	}

	/**
	 * Description ：根据专利id查找其他状况
	 * 
	 * @param zlId
	 *            ：专利id
	 */
	public Qtzk findQtzkById(String zlId) {
		return (Qtzk) this.getHibernateTemplate().get(Qtzk.class, zlId);
	}

	/**
	 * Description ：根据专利id查找其他状况，然后清除缓存
	 * 
	 * @param zlId
	 *            ：专利id
	 */
	public Qtzk findQtzkByIdClear(String zlId) {
		Qtzk qtzk;
		qtzk = (Qtzk) this.getHibernateTemplate().get(Qtzk.class, zlId);
		this.getHibernateTemplate().clear();
		return qtzk;
	}

	// ---------------------------------------------------------------
	/**
	 * Description ：保存其他共有专利人信息到数据库中
	 * 
	 * @param sharePeople
	 *            ：其他共有专利人持久化對象
	 */
	public void saveSharePeople(Sharepeople sharePeople) {
		this.getHibernateTemplate().saveOrUpdate(sharePeople);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新其他共有专利人信息到数据库中
	 * 
	 * @param sharePeople
	 *            ：其他共有专利人持久化對象
	 */
	public void updateSharePeople(Sharepeople sharePeople) {
		this.getHibernateTemplate().update(sharePeople);
	}

	/**
	 * Description ：根据专利Id查找专利共有人信息
	 * 
	 * @param zlId
	 *            ：专利Id
	 */
	public List findSharePeople(String zlId) {
		return this
				.getHibernateTemplate()
				.find(
						"from Sharepeople sharepeople where sharepeople.basicinfo.zlid = ?",
						zlId);
	}

	// ----------------------------------------------------------------
	/**
	 * Description ：保存附件及证明材料目录信息到数据库中
	 * 
	 * @param zjclinfo
	 *            ：证明材料目录持久化對象
	 */
	public void saveZjcl(Zjclinfo zjclinfo) {
		this.getHibernateTemplate().saveOrUpdate(zjclinfo);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新附件及证明材料目录信息到数据库中
	 * 
	 * @param zjclinfo
	 *            ：证明材料目录持久化對象
	 */
	public void updateZjcl(Zjclinfo zjclinfo) {
		this.getHibernateTemplate().update(zjclinfo);
	}

	/**
	 * Description ：根据专利Id查找附件及证明材料目录信息
	 * 
	 * @param zlId
	 *            ：专利Id
	 */
	public List findZjcl(String zlId) {
		return this.getHibernateTemplate().find(
				"from Zjclinfo zjclinfo where zjclinfo.basicinfo.zlid = ?",
				zlId);
	}

	// ------------------------------------------------------------------项目申报简介
	/**
	 * Description ：保存专利奖励申报项目简介
	 * 
	 * @param zlintro
	 *            ：专利简介持久化对象
	 */
	public void saveZlIntro(Zlintro zlintro) {
		this.getHibernateTemplate().save(zlintro);
		this.getHibernateTemplate().flush();
	}

	/**
	 * Description ：更新专利奖励申报项目简介
	 * 
	 * @param zlintro
	 *            ：专利简介持久化对象
	 */
	public void updateZlIntro(Zlintro zlintro) {
		this.getHibernateTemplate().update(zlintro);
	}

	/**
	 * Description ：根据专利Id查找专利申报简介信息
	 * 
	 * @param zlId
	 *            ：专利id
	 */
	public List findZlintro(String zlId) {
		return this.getHibernateTemplate().find(
				"from Zlintro zlintro where zlintro.zlid=?", zlId);
	}

	/**
	 * Description ：根据专利Id查找附件及证明材料目录信息==清除缓存
	 * 
	 * @param zlId
	 *            ：专利Id
	 */
	public Zlintro findZjclClear(String zlId) {
		Zlintro zlintro = (Zlintro) this.getHibernateTemplate().get(
				Zlintro.class, zlId);
		this.getHibernateTemplate().clear();
		return zlintro;
	}

	/**
	 * xyw新加：
	 */
	public Integer findFenShu1() {
		String hql = "select count(*) from TblXmfs1 where year="
				+ SysParameter.CURRENT_YEAR;
		return (Integer) this.getSession().createQuery(hql).uniqueResult();
	}

	/**
	 * xyw 查找数据库时间
	 */
	public String findShuJuKuTime() {
		// TODO Auto-generated method stub
		String hql = "from TblSystemparam t where t.paramName='beginTime'";
		TblSystemparam tsp = (TblSystemparam) this.getSession()
				.createQuery(hql).uniqueResult();
		if (null == tsp) {
			return "";
		}
		return tsp.getParamValue();
	}

	public String findShuJuKuTime2() {
		// TODO Auto-generated method stub
		String hql2 = "from TblSystemparam t where t.paramName='endTime'";
		TblSystemparam tsp2 = (TblSystemparam) this.getSession().createQuery(
				hql2).uniqueResult();
		if (null == tsp2) {
			return "";
		}
		return tsp2.getParamValue();
	}
}